home *** CD-ROM | disk | FTP | other *** search
/ Gold Medal Software 3 / Gold Medal Software - Volume 3 (Gold Medal) (1994).iso / bbsutils / smb_110a.arj / 100TO110.C next >
C/C++ Source or Header  |  1994-03-28  |  9KB  |  327 lines
  1. /* 100to110.C */
  2.  
  3. /* Converts SMB v1.00 message base to v1.10 (new index record field)        */
  4.  
  5. #include "smblib.h"
  6.  
  7. typedef struct {
  8.  
  9.     ushort    to;             // 16-bit CRC of recipient name (lower case)
  10.     ushort    from;            // 16-bit CRC of sender name (lower case)
  11.     ushort    subj;            // 16-bit CRC of subject (lower case, w/o RE:)
  12.     ushort    attr;            // attributes (read, permanent, etc.)
  13.     ulong    offset;         // offset into header file
  14.     ulong    number;         // number of message (1 based)
  15.  
  16.     } oldidxrec_t;
  17.  
  18.  
  19. /****************************************************************************/
  20. /* Fills msg->idx with message index based on msg->hdr.number                */
  21. /* OR if msg->hdr.number is 0, based on msg->offset (physical offset).        */
  22. /* if msg.hdr.number does not equal 0, then msg->offset is filled too.        */
  23. /* Either msg->hdr.number or msg->offset must be initialized before         */
  24. /* calling this function                                                    */
  25. /* Returns 1 if message number wasn't found, 0 if it was                    */
  26. /****************************************************************************/
  27. int smb_getoldmsgidx(smbmsg_t *msg)
  28. {
  29.     oldidxrec_t idx;
  30.     ulong     l,length,total,bot,top;
  31.  
  32. length=filelength(fileno(sid_fp));
  33. if(!length)
  34.     return(1);
  35. total=length/sizeof(oldidxrec_t);
  36. if(!total)
  37.     return(1);
  38.  
  39. bot=0;
  40. top=total;
  41. l=total/2; /* Start at middle index */
  42. while(1) {
  43.     fseek(sid_fp,l*sizeof(oldidxrec_t),SEEK_SET);
  44.     if(!fread(&idx,sizeof(oldidxrec_t),1,sid_fp))
  45.         return(1);
  46.     if(bot==top-1 && idx.number!=msg->hdr.number)
  47.         return(1);
  48.     if(idx.number>msg->hdr.number) {
  49.         top=l;
  50.         l=bot+((top-bot)/2);
  51.         continue; }
  52.     if(idx.number<msg->hdr.number) {
  53.         bot=l;
  54.         l=top-((top-bot)/2);
  55.         continue; }
  56.     break; }
  57. msg->idx.to=idx.to;
  58. msg->idx.from=idx.from;
  59. msg->idx.subj=idx.subj;
  60. msg->idx.attr=idx.attr;
  61. msg->idx.number=idx.number;
  62. msg->idx.offset=idx.offset;
  63. msg->offset=l;
  64. return(0);
  65. }
  66.  
  67. /****************************************************************************/
  68. /* Read header information into 'msg' structure                             */
  69. /* msg->idx.offset must be set before calling this function                 */
  70. /* Must call smb_freemsgmem() to free memory allocated for var len strs     */
  71. /* Returns 0 on success, non-zero if error                                    */
  72. /****************************************************************************/
  73. int smb_getoldmsghdr(smbmsg_t *msg)
  74. {
  75.     ushort    i;
  76.     ulong    l,offset;
  77.     idxrec_t idx;
  78.  
  79. fseek(shd_fp,msg->idx.offset,SEEK_SET);
  80. idx=msg->idx;
  81. offset=msg->offset;
  82. memset(msg,0,sizeof(smbmsg_t));
  83. msg->idx=idx;
  84. msg->offset=offset;
  85. if(!fread(&msg->hdr,sizeof(msghdr_t),1,shd_fp))
  86.     return(-1);
  87. if(memcmp(msg->hdr.id,"SHD\x1a",4))
  88.     return(-2);
  89. if(msg->hdr.version<0x100)
  90.     return(-9);
  91. l=sizeof(msghdr_t);
  92. if(msg->hdr.total_dfields && (msg->dfield
  93.     =(dfield_t *)MALLOC(sizeof(dfield_t)*msg->hdr.total_dfields))==NULL) {
  94.     smb_freemsgmem(*msg);
  95.     return(-3); }
  96. i=0;
  97. while(i<msg->hdr.total_dfields && l<msg->hdr.length) {
  98.     if(!fread(&msg->dfield[i],sizeof(dfield_t),1,shd_fp)) {
  99.         smb_freemsgmem(*msg);
  100.         return(-4); }
  101.     i++;
  102.     l+=sizeof(dfield_t); }
  103. if(i<msg->hdr.total_dfields) {
  104.     smb_freemsgmem(*msg);
  105.     return(-8); }
  106.  
  107. while(l<msg->hdr.length) {
  108.     i=msg->total_hfields;
  109.     if((msg->hfield_dat=(void **)REALLOC(msg->hfield_dat,sizeof(void *)*(i+1)))
  110.         ==NULL) {
  111.         smb_freemsgmem(*msg);
  112.         return(-3); }
  113.     if((msg->hfield=(hfield_t *)REALLOC(msg->hfield
  114.         ,sizeof(hfield_t)*(i+1)))==NULL) {
  115.         smb_freemsgmem(*msg);
  116.         return(-3); }
  117.     msg->total_hfields++;
  118.     if(!fread(&msg->hfield[i],sizeof(hfield_t),1,shd_fp)) {
  119.         smb_freemsgmem(*msg);
  120.         return(-5); }
  121.     l+=sizeof(hfield_t);
  122.     if((msg->hfield_dat[i]=(char *)MALLOC(msg->hfield[i].length+1))
  123.         ==NULL) {            /* Allocate 1 extra for NULL terminator */
  124.         smb_freemsgmem(*msg);  /* or 0 length field */
  125.         return(-3); }
  126.     memset(msg->hfield_dat[i],0,msg->hfield[i].length+1);  /* init to NULL */
  127.     if(msg->hfield[i].length
  128.         && !fread(msg->hfield_dat[i],msg->hfield[i].length,1,shd_fp)) {
  129.         smb_freemsgmem(*msg);
  130.         return(-6); }
  131.     switch(msg->hfield[i].type) {    /* convenience variables */
  132.         case SENDER:
  133.             msg->from=msg->hfield_dat[i];
  134.             break;
  135.         case SENDERAGENT:
  136.             msg->from_agent=*(ushort *)msg->hfield_dat[i];
  137.             break;
  138.         case SENDEREXT:
  139.             msg->from_ext=msg->hfield_dat[i];
  140.             break;
  141.         case SENDERNETTYPE:
  142.             msg->from_net.type=*(ushort *)msg->hfield_dat[i];
  143.             break;
  144.         case SENDERNETADDR:
  145.             msg->from_net.addr=msg->hfield_dat[i];
  146.             break;
  147.         case REPLYTO:
  148.             msg->replyto=msg->hfield_dat[i];
  149.             break;
  150.         case REPLYTOEXT:
  151.             msg->replyto_ext=msg->hfield_dat[i];
  152.             break;
  153.         case REPLYTOAGENT:
  154.             msg->replyto_agent=*(ushort *)msg->hfield_dat[i];
  155.             break;
  156.         case REPLYTONETTYPE:
  157.             msg->replyto_net.type=*(ushort *)msg->hfield_dat[i];
  158.             break;
  159.         case REPLYTONETADDR:
  160.             msg->replyto_net.addr=msg->hfield_dat[i];
  161.             break;
  162.         case RECIPIENT:
  163.             msg->to=msg->hfield_dat[i];
  164.             break;
  165.         case RECIPIENTEXT:
  166.             msg->to_ext=msg->hfield_dat[i];
  167.             break;
  168.         case RECIPIENTAGENT:
  169.             msg->to_agent=*(ushort *)msg->hfield_dat[i];
  170.             break;
  171.         case RECIPIENTNETTYPE:
  172.             msg->to_net.type=*(ushort *)msg->hfield_dat[i];
  173.             break;
  174.         case RECIPIENTNETADDR:
  175.             msg->to_net.addr=msg->hfield_dat[i];
  176.             break;
  177.         case SUBJECT:
  178.             msg->subj=msg->hfield_dat[i];
  179.             break; }
  180.     l+=msg->hfield[i].length; }
  181.  
  182. if(!msg->from || !msg->to || !msg->subj) {
  183.     smb_freemsgmem(*msg);
  184.     return(-7); }
  185. return(0);
  186. }
  187.  
  188.  
  189. /****************************************************************************/
  190. /* Open a message base of name 'smb_file'                                   */
  191. /* Opens files for READing messages or updating message indices only        */
  192. /****************************************************************************/
  193. int smb_oldopen()
  194. {
  195.     int file;
  196.     char str[128];
  197.  
  198. sprintf(str,"%s.SDT",smb_file);
  199. if((file=open(str,O_RDWR|O_CREAT|O_BINARY|O_DENYNONE,S_IWRITE|S_IREAD))==-1
  200.     || (sdt_fp=fdopen(file,"r+b"))==NULL)
  201.     return(1);
  202. setvbuf(sdt_fp,NULL,_IOFBF,2*1024);
  203.  
  204. sprintf(str,"%s.SHD",smb_file);
  205. if((file=open(str,O_RDWR|O_CREAT|O_BINARY|O_DENYNONE,S_IWRITE|S_IREAD))==-1
  206.     || (shd_fp=fdopen(file,"r+b"))==NULL)
  207.     return(2);
  208. setvbuf(shd_fp,NULL,_IOFBF,2*1024);
  209.  
  210. sprintf(str,"%s.SID",smb_file);
  211. if((file=open(str,O_RDWR|O_CREAT|O_BINARY|O_DENYNONE,S_IWRITE|S_IREAD))==-1
  212.     || (sid_fp=fdopen(file,"r+b"))==NULL)
  213.     return(3);
  214. setvbuf(sid_fp,NULL,_IOFBF,2*1024);
  215.  
  216. return(0);
  217. }
  218.  
  219.  
  220. int main(int argc, char **argv)
  221. {
  222.     char    *p;
  223.     int     x,i;
  224.     ulong    size,l,length;
  225.     FILE    *sid_tmp;
  226.     idxrec_t idx;
  227.     smbmsg_t msg;
  228.     smbhdr_t hdr;
  229.     smbstatus_t status;
  230.  
  231. printf("\nSMB v1.00 to v1.10 conversion utility\n");
  232.  
  233. if(argc<2) {
  234.     printf("\nusage: 100to110 <filespec.SHD>\n");
  235.     return(1); }
  236.  
  237. for(x=1;x<argc;x++) {
  238.  
  239.     strcpy(smb_file,argv[x]);
  240.     p=strrchr(smb_file,'.');
  241.     if(p) *p=0;
  242.     strupr(smb_file);
  243.  
  244.     printf("\nConverting %s\r\n",smb_file);
  245.  
  246.     if((i=smb_oldopen())!=0) {
  247.         printf("smb_open returned %d\n",i);
  248.         continue; }
  249.  
  250.     if(filelength(fileno(shd_fp))<sizeof(smbhdr_t)) {
  251.         printf("Empty\n");
  252.         smb_close();
  253.         continue; }
  254.  
  255.     if((i=smb_locksmbhdr(10))!=0) {
  256.         smb_close();
  257.         printf("smb_locksmbhdr returned %d\n",i);
  258.         continue; }
  259.  
  260.     fread(&hdr,sizeof(smbhdr_t),1,shd_fp);
  261.     hdr.version=SMB_VERSION;
  262.     fseek(shd_fp,0L,SEEK_SET);
  263.     fwrite(&hdr,sizeof(smbhdr_t),1,shd_fp);
  264.  
  265.     if((i=smb_getstatus(&status))!=0) {
  266.         smb_unlocksmbhdr();
  267.         smb_close();
  268.         printf("smb_getstatus returned %d\n",i);
  269.         continue; }
  270.  
  271.     sid_tmp=tmpfile();
  272.  
  273.     length=filelength(fileno(shd_fp));
  274.  
  275.     for(l=status.header_offset;l<length;l+=size) {
  276.         printf("\r%2u%%  ",l ? (long)(100.0/((float)length/l)) : 0);
  277.         msg.idx.offset=l;
  278.         if((i=smb_lockmsghdr(msg,10))!=0) {
  279.             printf("\n(%06lX) smb_lockmsghdr returned %d\n",l,i);
  280.             size=SHD_BLOCK_LEN;
  281.             continue; }
  282.         if((i=smb_getoldmsghdr(&msg))!=0) {
  283.             smb_unlockmsghdr(msg);
  284.             printf("\n(%06lX) smb_getmsghdr returned %d\n",l,i);
  285.             size=SHD_BLOCK_LEN;
  286.             continue; }
  287.         printf("#%-5lu (%06lX) %-25.25s ",msg.hdr.number,l,msg.from);
  288.         size=smb_getmsghdrlen(msg);
  289.         while(size%SHD_BLOCK_LEN)
  290.             size++;
  291.  
  292.         msg.hdr.version=SMB_VERSION;
  293.         if((i=smb_putmsghdr(msg))!=0) {
  294.             smb_unlockmsghdr(msg);
  295.             printf("\n(%06lX) smb_putmsghdr returned %d\n",l,i);
  296.             continue; }
  297.  
  298.         smb_unlockmsghdr(msg);
  299.         smb_freemsgmem(msg);
  300.  
  301.         if(msg.hdr.attr&MSG_DELETE) {
  302.             printf("Deleted\n");
  303.             continue; }
  304.         if(smb_getoldmsgidx(&msg)) {
  305.             printf("Not found in index\n");
  306.             continue; }
  307.         msg.idx.time=msg.hdr.when_imported.time;
  308.         fseek(sid_tmp,msg.offset*sizeof(idxrec_t),SEEK_SET);
  309.         fwrite(&msg.idx,sizeof(idxrec_t),1,sid_tmp); }
  310.  
  311.     printf("\n\nCreating new index...\n");
  312.     rewind(sid_fp);
  313.     chsize(fileno(sid_fp),0L);
  314.     fseek(sid_tmp,0L,SEEK_SET);
  315.     l=0;
  316.     while(1) {
  317.         printf("%lu\r",l++);
  318.         if(!fread(&idx,sizeof(idxrec_t),1,sid_tmp))
  319.             break;
  320.         fwrite(&idx,sizeof(idxrec_t),1,sid_fp); }
  321.     printf("\r%79s\r100%%\n","");
  322.     fclose(sid_tmp);
  323.     smb_close();
  324.     }
  325. return(0);
  326. }
  327.